// Murus Gallicus and Advanced Murus Gallicus by Phil Leduc

// Move a tower (2-stack) in any direction into the two nearest cells if the
// destination cells are empty or contain a mover/own singleton (1-stack).
(define "MoveTower"
    (move Hop
        (from if:(and (is Mover (who at:(from)))
                (= (size Stack at:(from)) 2)
            ) 
        )
        (between if:(or 
                (is Empty (between))
                (and 
                    (is Mover (who at:(between)))
                    (< (size Stack at:(between)) <Stack:limit>) 
                ) 
            ) 
            (apply (fromTo (from) (to (between))))
        )
        
        (to if:(or 
                (is Empty (to))
                (and (is Mover (who at:(to)))
                    (< (size Stack at:(to)) <Stack:limit>)
                ) 
            ) 
        )
        stack:True
    )
)

// Sacrifice a tower piece in order to remove an adjacent enemy wall/singleton piece.
(define "SacrificeCaptureWall"
    (move Step
        (from if:(and (is Mover (who at:(from)))
                (= (size Stack at:(from)) 2)
            ) 
        )
        (to 
            if:(and ("IsEnemyAt" (to)) ("IsSingletonStack" (to)))
            (apply (remove (to))) // This removes the only enemy piece in the 'to' cell.
        )
        stack:True
        (then
            (and
                (fromTo
                    (from (last To))
                    (to (last From))
                )
                (remove (last To))  
            ) 
        )
    )
)
// Sacrifice a tower piece or two in order to remove one or two enemy stones 
// from a 3-stack/catapult.
(define "SacrificeCaptureCatapult"
    (move Step
        (from if:(and (is Mover (who at:(from)))
                (= (size Stack at:(from)) 2)
            ) 
        )
        (to 
            if:(and ("IsEnemyAt" (to)) (= (size Stack at:(to)) 3))
            (apply (remove (to))) // This removes one enemy piece in the 'to' cell.
        )
        stack:True
        (then
            (and {
                (fromTo
                    (from (last To))
                    (to (last From))
                )
                (remove (last To)) 
                (moveAgain) 
            }) 
        )
    )
)

// Throw a stone left, diagonally left, straight ahead, diagonally right, or right two or three cells regardless
// of what is between the 3-stack and the target EMPTY cell.
(define "ThrowStonetoEmpty"
    (move Hop
        (from if:(and (is Mover (who at:(from)))
                (= (size Stack at:(from)) 3)
            ) 
        )          
        (difference All Backwards)
        (between (range 1 2) if:True)
        (to if:
            (and
                (not ("IsEnemyAt" (to))) 
                (not (is Mover (who at:(to)))) 
            )
        )
    )
)

// Throw a stone left, diagonally left, straight ahead, diagonally right, or right two or three cells regardless
// of what is between the 3-stack and the target ENEMY-OCCUPIED cell.
(define "ThrowStonetoEnemy"
    (move Hop
        (from if:(and (is Mover (who at:(from)))
                (= (size Stack at:(from)) 3)
            ) 
        )          
        (difference All Backwards)
        (between (range 1 2) if:True)
        (to if:
            ("IsEnemyAt" (to)) 
        )
        (then
            (and
                (remove (last To))
                (remove (last To))
            )
        )
    )
)

//**************************************************************************************************

(game "Murus Gallicus" 
    ("TwoPlayersNorthSouth") 
    (equipment { 
        (board (<Board:shape>)) 
        (piece "Counter_isometric" Each) 
        
        (regions "RomanGoal1" P1 (sites Top))
        (regions "GaulGoal2" P2 (sites Bottom))
        
    }) 
    (rules
        (start {
            (place Stack "Counter_isometric1" (sites {<Board:rangeP1>}) count:2)
            (place Stack "Counter_isometric2" (sites {<Board:rangeP2>}) count:2)
        }) 
        
        (play
            (if ("SameTurn")
                (or
                    (move
                        (from (last From))
                        (to (last To)) 
                        stack:True    
                        (then 
                            (and 
                                (remove (last To)) 
                                (remove (last To)) 
                            )
                        )    
                    )    
                    (move Pass)
                )
                (forEach Piece "Counter_isometric"
                    (or  
                        {
                        "MoveTower"
                        "SacrificeCaptureWall"
                        
                        "SacrificeCaptureCatapult"
                        "ThrowStonetoEmpty"
                        "ThrowStonetoEnemy"
                        }
                    )
                    top:True
                )
            )   
        )
        
        (end {
            ("BlockWin")
            <End:event>
        })
    )
)

//------------------------------------------------------------------------------

(option "Stacking Limit" <Stack> args:{ <limit> }
    {
    (item "Standard"  <2> "Stack limit is 2.")*
    (item "Advanced"  <3> "Stack limit is 3.")
    }
)

(option "Board" <Board> args:{ <shape> <rangeP1> <rangeP2>}
    {
    (item "Rectangle 7 x 8 1r"  <rectangle 7 8> <0..7> <48..55> "Standard 7 x 8, one row")*
    (item "Square 8 x 8 1r"   <square 8>   <0..7> <56..63>  "Square 8 x 8, one row")
    (item "Square 8 x 8 2r"   <square 8>   <0..15> <48..63> "Square 8 x 8, two rows")
    (item "Hex 5 x 5 x 5 2r"   <hex 5>    <0..10> <50..60>  "Hexhex base 5, two rows.")
    }
)

(option "End Game" <End> args:{ <event> }
    {
    (item "Immediate"  
        <
        (if 
            (and 
                {
                (is In (last To) (sites Mover)) 
                (not ("IsEnemyAt" (last To)))
                (is Mover (who at:(last To)))
                } 
            )
            (result Mover Win)
        )
        > 
        "Immediately after reaching goal." 
    )* 
    (item "Delayed"  
        <
        (if (= 1 (count Sites in:(intersection (sites Occupied by:Next) (sites Next) ) ))
            (result Next Win)
        )
        > 
        "After opponent's last chance to remove invader." 
    ) 
    }
)

//------------------------------------------------------------------------------

(rulesets { 
    
    (ruleset "Ruleset/Murus Galicus (Described)" {
        "Board/Rectangle 7 x 8 1r" 
        "Stacking Limit/Standard"
        "End Game/Immediate"
    })*
    
    (ruleset "Ruleset/Advanced Murus Galicus (Described)" {
        "Board/Rectangle 7 x 8 1r" 
        "Stacking Limit/Advanced"
        "End Game/Delayed"
    })
    
})

//------------------------------------------------------------------------------

(metadata 
    
    (info
        {
        (description "Murus Gallicus is a breakthrough game of material balance, tactics, area control, and timing.")
        (useFor "Ruleset/Murus Galicus (Described)" (rules "On a player's turn he or she must perform one of the following actions:
            1) Move a tower (2-stack) by distributing its two stones into the two nearest cells in any one direction. Each destination cell must be empty or contain a single friendly stone. 
        2) Sacrifice a single tower stone to remove an adjacent enemy wall (1-stack). Sacrifice is not forced.
Goal: A player wins immediately by reaching any cell of his or her opponent's home row, or by stalemating his or her opponent."))
(useFor "Ruleset/Murus Galicus (Described)" (id "1647"))
(useFor "Ruleset/Advanced Murus Galicus (Described)" (rules "On a player's turn he or she must perform one of the following actions:
    1) Move a tower (2-stack) by distributing its two stones into the two nearest cells in any one direction. Each destination cell must be empty or contain one or two friendly stones. 
2) Catapults (3-stack) may throw a stone, in a forward, diagonally forward, or lateral direction, two or three cells/spaces.
3) Sacrifice a single tower stone to remove an adjacent enemy wall (1-stack). Sacrifice is not forced.
4) Sacrifice one or two tower stones to remove one or two stones from an enemy catapult (3-stack). NOTE: A player may pass after sacrificing just one stone against a catapult.
Goal: A player wins by reaching any cell of his or her opponent's home row and the stone survives until the player next turn, or by stalemating his or her opponent."))
(useFor "Ruleset/Advanced Murus Galicus (Described)" (id "1648"))
(source "<a href=\"https://boardgamegeek.com/boardgame/55131/murus-gallicus\" target=\"_blank\" class=\"style1\" style=\"color: #0000EE\" />BGG</a><a href=\"https://sites.google.com/site/theowlsnest02/home/murus-gallicus\" target=\"_blank\" class=\"style1\" style=\"color: #0000EE\" />The Owl's Nest - Murus Gallicus</a><a href=\"https://nestorgames.com/rulebooks/MURUSGALLICUS_EN.pdf\" target=\"_blank\" class=\"style1\" style=\"color: #0000EE\" />Nestor Games</a>")
(id "1647")
(version "1.3.12")
(classification "board/race/reach")
(author "Phil Leduc")
(publisher "<a href=\"https://www.nestorgames.com\" target=\"_blank\" class=\"style1\" style=\"color: #0000EE\" />nestorgames</a>")
(credit "Phil Leduc")
(date "2009")
}
)

(graphics {
    (board Colour InnerEdges (colour GunMetal))
    (board Colour OuterEdges (colour 0 0 0))
    (board Colour Phase0 (colour "#FCFCE1"))
    (board Colour Phase1 (colour "#FCFCE1"))
    (player Colour P1 (colour HumanLight))
    (player Colour P2 (colour Brown))
})  

)